默认方法

概述

在Java 8中，接口引入了一个新的特性——默认方法（Default Methods）。默认方法允许我们在接口中提供方法的默认实现。这使得接口在扩展时更加灵活，避免了实现类必须为每个接口方法提供实现的负担。

为什么需要默认方法？

在Java 8之前，接口中的方法只能是抽象的，这意味着实现该接口的类必须为接口中的每个方法提供具体的实现。如果接口需要添加新的方法，那么所有实现该接口的类都必须修改以提供新方法的实现。这可能会导致代码的重大改动和维护的困难。

默认方法的引入解决了这个问题。通过在接口中提供方法的默认实现，我们可以在不破坏现有实现类的情况下扩展接口的功能。

默认方法的语法

默认方法使用default关键字来定义，并且必须提供方法体。语法如下：

public interface MyInterface {
    void abstractMethod(); // 抽象方法

    default void defaultMethod() {
        // 默认方法的实现
        System.out.println("This is a default method.");
    }
}

默认方法的使用

示例1：基本使用

public interface Greeting {
    void greet();

    default void sayHello() {
        System.out.println("Hello from default method!");
    }
}

public class EnglishGreeting implements Greeting {
    @Override
    public void greet() {
        System.out.println("Hello!");
    }
}

public class Main {
    public static void main(String[] args) {
        Greeting englishGreeting = new EnglishGreeting();
        englishGreeting.greet(); // 输出: Hello!
        englishGreeting.sayHello(); // 输出: Hello from default method!
    }
}

在这个示例中，Greeting接口定义了一个抽象方法greet()和一个默认方法sayHello()。EnglishGreeting类实现了Greeting接口，并提供了greet()方法的实现。由于sayHello()是默认方法，EnglishGreeting类不需要实现它，但仍然可以使用它。

示例2：多重继承中的默认方法

在Java中，类可以实现多个接口。如果这些接口中有相同的默认方法，那么实现类必须解决这个冲突。

public interface A {
    default void show() {
        System.out.println("Interface A");
    }
}

public interface B {
    default void show() {
        System.out.println("Interface B");
    }
}

public class MyClass implements A, B {
    @Override
    public void show() {
        A.super.show(); // 调用接口A的默认方法
        B.super.show(); // 调用接口B的默认方法
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.show(); // 输出: Interface A 和 Interface B
    }
}

在这个示例中，MyClass类实现了两个接口A和B，这两个接口都有一个名为show()的默认方法。为了解决冲突，MyClass类必须重写show()方法，并明确调用哪个接口的默认方法。

实践练习

练习1：扩展接口

假设你有一个名为Calculator的接口，其中包含一个抽象方法calculate()。现在，你需要在不修改现有实现类的情况下，为Calculator接口添加一个新的默认方法displayResult()。

public interface Calculator {
    int calculate(int a, int b);

    default void displayResult(int result) {
        System.out.println("The result is: " + result);
    }
}

public class BasicCalculator implements Calculator {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new BasicCalculator();
        int result = calculator.calculate(5, 3);
        calculator.displayResult(result); // 输出: The result is: 8
    }
}

练习2：解决默认方法冲突

创建两个接口Shape和Color，每个接口都有一个名为display()的默认方法。然后创建一个类Circle，它同时实现这两个接口，并解决display()方法的冲突。

public interface Shape {
    default void display() {
        System.out.println("Shape");
    }
}

public interface Color {
    default void display() {
        System.out.println("Color");
    }
}

public class Circle implements Shape, Color {
    @Override
    public void display() {
        Shape.super.display();
        Color.super.display();
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.display(); // 输出: Shape 和 Color
    }
}

总结

默认方法是Java 8引入的一个重要特性，它使得接口在扩展时更加灵活和易于维护。通过提供默认实现，我们可以在不破坏现有实现类的情况下为接口添加新功能。理解默认方法的使用和解决多重继承中的冲突是掌握这一特性的关键。

希望这篇教程能帮助你更好地理解和应用默认方法。继续学习和实践，你将能够更熟练地使用这一强大的Java特性。